
sequence_queue:     file format elf32-littlearm


Disassembly of section .init:

000103f0 <_init>:
   103f0:	e1a0c00d 	mov	ip, sp
   103f4:	e92ddff0 	push	{r4, r5, r6, r7, r8, r9, sl, fp, ip, lr, pc}
   103f8:	e24cb004 	sub	fp, ip, #4
   103fc:	e91baff0 	ldmdb	fp, {r4, r5, r6, r7, r8, r9, sl, fp, sp, pc}

Disassembly of section .plt:

00010400 <printf@plt-0x14>:
   10400:	e52de004 	push	{lr}		; (str lr, [sp, #-4]!)
   10404:	e59fe004 	ldr	lr, [pc, #4]	; 10410 <_init+0x20>
   10408:	e08fe00e 	add	lr, pc, lr
   1040c:	e5bef008 	ldr	pc, [lr, #8]!
   10410:	00010cb4 	.word	0x00010cb4

00010414 <printf@plt>:
   10414:	e28fc600 	add	ip, pc, #0, 12
   10418:	e28cca10 	add	ip, ip, #16, 20	; 0x10000
   1041c:	e5bcfcb4 	ldr	pc, [ip, #3252]!	; 0xcb4

00010420 <puts@plt>:
   10420:	e28fc600 	add	ip, pc, #0, 12
   10424:	e28cca10 	add	ip, ip, #16, 20	; 0x10000
   10428:	e5bcfcac 	ldr	pc, [ip, #3244]!	; 0xcac

0001042c <malloc@plt>:
   1042c:	e28fc600 	add	ip, pc, #0, 12
   10430:	e28cca10 	add	ip, ip, #16, 20	; 0x10000
   10434:	e5bcfca4 	ldr	pc, [ip, #3236]!	; 0xca4

00010438 <abort@plt>:
   10438:	e28fc600 	add	ip, pc, #0, 12
   1043c:	e28cca10 	add	ip, ip, #16, 20	; 0x10000
   10440:	e5bcfc9c 	ldr	pc, [ip, #3228]!	; 0xc9c

00010444 <__deregister_frame_info@plt>:
   10444:	e28fc600 	add	ip, pc, #0, 12
   10448:	e28cca10 	add	ip, ip, #16, 20	; 0x10000
   1044c:	e5bcfc94 	ldr	pc, [ip, #3220]!	; 0xc94

00010450 <realloc@plt>:
   10450:	e28fc600 	add	ip, pc, #0, 12
   10454:	e28cca10 	add	ip, ip, #16, 20	; 0x10000
   10458:	e5bcfc8c 	ldr	pc, [ip, #3212]!	; 0xc8c

0001045c <__uClibc_main@plt>:
   1045c:	e28fc600 	add	ip, pc, #0, 12
   10460:	e28cca10 	add	ip, ip, #16, 20	; 0x10000
   10464:	e5bcfc84 	ldr	pc, [ip, #3204]!	; 0xc84

00010468 <exit@plt>:
   10468:	e28fc600 	add	ip, pc, #0, 12
   1046c:	e28cca10 	add	ip, ip, #16, 20	; 0x10000
   10470:	e5bcfc7c 	ldr	pc, [ip, #3196]!	; 0xc7c

00010474 <__register_frame_info@plt>:
   10474:	e28fc600 	add	ip, pc, #0, 12
   10478:	e28cca10 	add	ip, ip, #16, 20	; 0x10000
   1047c:	e5bcfc74 	ldr	pc, [ip, #3188]!	; 0xc74

00010480 <raise@plt>:
   10480:	e28fc600 	add	ip, pc, #0, 12
   10484:	e28cca10 	add	ip, ip, #16, 20	; 0x10000
   10488:	e5bcfc6c 	ldr	pc, [ip, #3180]!	; 0xc6c

0001048c <free@plt>:
   1048c:	e28fc600 	add	ip, pc, #0, 12
   10490:	e28cca10 	add	ip, ip, #16, 20	; 0x10000
   10494:	e5bcfc64 	ldr	pc, [ip, #3172]!	; 0xc64

Disassembly of section .text:

00010498 <_start>:
   10498:	e3a0b000 	.word	0xe3a0b000
   1049c:	e3a0e000 	.word	0xe3a0e000
   104a0:	e49d1004 	.word	0xe49d1004
   104a4:	e1a0200d 	.word	0xe1a0200d
   104a8:	e52d2004 	.word	0xe52d2004
   104ac:	e52d0004 	.word	0xe52d0004
   104b0:	e59fc010 	.word	0xe59fc010
   104b4:	e52dc004 	.word	0xe52dc004
   104b8:	e59f000c 	.word	0xe59f000c
   104bc:	e59f300c 	.word	0xe59f300c
   104c0:	eaffffe5 	.word	0xeaffffe5
   104c4:	ebffffdb 	.word	0xebffffdb
   104c8:	00010f18 	.word	0x00010f18
   104cc:	00010a7c 	.word	0x00010a7c
   104d0:	000103f0 	.word	0x000103f0

000104d4 <deregister_tm_clones>:
   104d4:	e59f301c 	ldr	r3, [pc, #28]	; 104f8 <deregister_tm_clones+0x24>
   104d8:	e59f001c 	ldr	r0, [pc, #28]	; 104fc <deregister_tm_clones+0x28>
   104dc:	e0603003 	rsb	r3, r0, r3
   104e0:	e3530006 	cmp	r3, #6
   104e4:	912fff1e 	bxls	lr
   104e8:	e59f3010 	ldr	r3, [pc, #16]	; 10500 <deregister_tm_clones+0x2c>
   104ec:	e3530000 	cmp	r3, #0
   104f0:	012fff1e 	bxeq	lr
   104f4:	e12fff13 	bx	r3
   104f8:	00021107 	.word	0x00021107
   104fc:	00021104 	.word	0x00021104
   10500:	00000000 	.word	0x00000000

00010504 <register_tm_clones>:
   10504:	e59f1024 	ldr	r1, [pc, #36]	; 10530 <register_tm_clones+0x2c>
   10508:	e59f0024 	ldr	r0, [pc, #36]	; 10534 <register_tm_clones+0x30>
   1050c:	e0601001 	rsb	r1, r0, r1
   10510:	e1a01141 	asr	r1, r1, #2
   10514:	e0811fa1 	add	r1, r1, r1, lsr #31
   10518:	e1b010c1 	asrs	r1, r1, #1
   1051c:	012fff1e 	bxeq	lr
   10520:	e59f3010 	ldr	r3, [pc, #16]	; 10538 <register_tm_clones+0x34>
   10524:	e3530000 	cmp	r3, #0
   10528:	012fff1e 	bxeq	lr
   1052c:	e12fff13 	bx	r3
   10530:	00021104 	.word	0x00021104
   10534:	00021104 	.word	0x00021104
   10538:	00000000 	.word	0x00000000

0001053c <__do_global_dtors_aux>:
   1053c:	e92d4010 	push	{r4, lr}
   10540:	e59f402c 	ldr	r4, [pc, #44]	; 10574 <__do_global_dtors_aux+0x38>
   10544:	e5d43000 	ldrb	r3, [r4]
   10548:	e3530000 	cmp	r3, #0
   1054c:	18bd8010 	popne	{r4, pc}
   10550:	ebffffdf 	bl	104d4 <deregister_tm_clones>
   10554:	e59f301c 	ldr	r3, [pc, #28]	; 10578 <__do_global_dtors_aux+0x3c>
   10558:	e3530000 	cmp	r3, #0
   1055c:	0a000001 	beq	10568 <__do_global_dtors_aux+0x2c>
   10560:	e59f0014 	ldr	r0, [pc, #20]	; 1057c <__do_global_dtors_aux+0x40>
   10564:	ebffffb6 	bl	10444 <__deregister_frame_info@plt>
   10568:	e3a03001 	mov	r3, #1
   1056c:	e5c43000 	strb	r3, [r4]
   10570:	e8bd8010 	pop	{r4, pc}
   10574:	00021104 	.word	0x00021104
   10578:	00000000 	.word	0x00000000
   1057c:	00010f90 	.word	0x00010f90

00010580 <frame_dummy>:
   10580:	e59f3040 	ldr	r3, [pc, #64]	; 105c8 <frame_dummy+0x48>
   10584:	e92d4010 	push	{r4, lr}
   10588:	e3530000 	cmp	r3, #0
   1058c:	0a000002 	beq	1059c <frame_dummy+0x1c>
   10590:	e59f1034 	ldr	r1, [pc, #52]	; 105cc <frame_dummy+0x4c>
   10594:	e59f0034 	ldr	r0, [pc, #52]	; 105d0 <frame_dummy+0x50>
   10598:	ebffffb5 	bl	10474 <__register_frame_info@plt>
   1059c:	e59f0030 	ldr	r0, [pc, #48]	; 105d4 <frame_dummy+0x54>
   105a0:	e5903000 	ldr	r3, [r0]
   105a4:	e3530000 	cmp	r3, #0
   105a8:	1a000001 	bne	105b4 <frame_dummy+0x34>
   105ac:	e8bd4010 	pop	{r4, lr}
   105b0:	eaffffd3 	b	10504 <register_tm_clones>
   105b4:	e59f301c 	ldr	r3, [pc, #28]	; 105d8 <frame_dummy+0x58>
   105b8:	e3530000 	cmp	r3, #0
   105bc:	0afffffa 	beq	105ac <frame_dummy+0x2c>
   105c0:	e12fff33 	blx	r3
   105c4:	eafffff8 	b	105ac <frame_dummy+0x2c>
   105c8:	00000000 	.word	0x00000000
   105cc:	00021108 	.word	0x00021108
   105d0:	00010f90 	.word	0x00010f90
   105d4:	00021008 	.word	0x00021008
   105d8:	00000000 	.word	0x00000000

000105dc <again_malloc>:
  int front, rear, len;
  int max_size;
};

void again_malloc(struct queue * src)
{
   105dc:	e92d4800 	push	{fp, lr}
   105e0:	e28db004 	add	fp, sp, #4
   105e4:	e24dd010 	sub	sp, sp, #16
   105e8:	e50b0010 	str	r0, [fp, #-16] ; src
  int * des;
  int i;

  des = realloc(src->queue, 2 * src->max_size * sizeof(int));
   105ec:	e51b3010 	ldr	r3, [fp, #-16]    ; src 
   105f0:	e5932000 	ldr	r2, [r3]          ; r2 = src-queue
   105f4:	e51b3010 	ldr	r3, [fp, #-16]    ; r3 = src
   105f8:	e5933010 	ldr	r3, [r3, #16]     ; r3 = src->max_size
   105fc:	e1a03183 	lsl	r3, r3, #3        ; r3 = r3 * 8
   10600:	e1a01003 	mov	r1, r3
   10604:	e1a00002 	mov	r0, r2
   10608:	ebffff90 	bl	10450 <realloc@plt>
   1060c:	e50b000c 	str	r0, [fp, #-12]    ; des = realloc return value
  if (des == NULL) {
   10610:	e51b300c 	ldr	r3, [fp, #-12] ; des = realloc return value
   10614:	e3530000 	cmp	r3, #0
   10618:	1a000003 	bne	1062c <again_malloc+0x50>
    printf("realloc fail.\n");
   1061c:	e59f00d0 	ldr	r0, [pc, #208]	; 106f4 <again_malloc+0x118>
   10620:	ebffff7e 	bl	10420 <puts@plt>
    exit(1);
   10624:	e3a00001 	mov	r0, #1
   10628:	ebffff8e 	bl	10468 <exit@plt>
  }

  src->queue = des;
   1062c:	e51b3010 	ldr	r3, [fp, #-16] ; src
   10630:	e51b200c 	ldr	r2, [fp, #-12] ; des
   10634:	e5832000 	str	r2, [r3]       ; des = src->queue

  if (src->rear != src->max_size -1) {
   10638:	e51b3010 	ldr	r3, [fp, #-16] ; src
   1063c:	e5932008 	ldr	r2, [r3, #8]   ; src->rear
   10640:	e51b3010 	ldr	r3, [fp, #-16] ; src
   10644:	e5933010 	ldr	r3, [r3, #16]  ; src->max_size
   10648:	e2433001 	sub	r3, r3, #1     ; src->max_size-1
   1064c:	e1520003 	cmp	r2, r3
   10650:	0a000020 	beq	106d8 <again_malloc+0xfc>
    for (i = 0; i <= src->max_size; i++)
   10654:	e3a03000 	mov	r3, #0 
   10658:	e50b3008 	str	r3, [fp, #-8] ; i
   1065c:	ea000011 	b	106a8 <again_malloc+0xcc>
      src->queue[i + src->max_size] = src->queue[i];
   10660:	e51b3010 	ldr	r3, [fp, #-16]  ; src
   10664:	e5932000 	ldr	r2, [r3]        ; src->queue
   10668:	e51b3010 	ldr	r3, [fp, #-16]  ; r3 = src
   1066c:	e5931010 	ldr	r1, [r3, #16]   ; src->max_size
   10670:	e51b3008 	ldr	r3, [fp, #-8]   ; r3 = i
        
   10674:	e0813003 	add	r3, r1, r3      ; i = src->max_size+i
   10678:	e1a03103 	lsl	r3, r3, #2      ; i = i << 2
   1067c:	e0823003 	add	r3, r2, r3      ; i = src->queue+i<<2
        
   10680:	e51b2010 	ldr	r2, [fp, #-16]  ; r2 = src
   10684:	e5921000 	ldr	r1, [r2]        ; r1 = src->queue
   10688:	e51b2008 	ldr	r2, [fp, #-8]   ; r2 = i
        
   1068c:	e1a02102 	lsl	r2, r2, #2      ; i = i << 2;
   10690:	e0812002 	add	r2, r1, r2      ; i = src->queue+i
   10694:	e5922000 	ldr	r2, [r2]        ; src->queue[i]
   10698:	e5832000 	str	r2, [r3]        ; src->queue[i+src->max_size] = r2
  }

  src->queue = des;

  if (src->rear != src->max_size -1) {
    for (i = 0; i <= src->max_size; i++)
   1069c:	e51b3008 	ldr	r3, [fp, #-8] ; r3 = i
   106a0:	e2833001 	add	r3, r3, #1    ; i+1
   106a4:	e50b3008 	str	r3, [fp, #-8] ; i=i+1
   106a8:	e51b3010 	ldr	r3, [fp, #-16] ; src
   106ac:	e5932010 	ldr	r2, [r3, #16]  ; src->max_size
   106b0:	e51b3008 	ldr	r3, [fp, #-8]  ; r3 = i
   106b4:	e1520003 	cmp	r2, r3
   106b8:	aaffffe8 	bge	10660 <again_malloc+0x84>
      src->queue[i + src->max_size] = src->queue[i];
    
    src->rear += src->max_size;
   106bc:	e51b3010 	ldr	r3, [fp, #-16] ; src
   106c0:	e5932008 	ldr	r2, [r3, #8]   ; r2 = src->rear
   106c4:	e51b3010 	ldr	r3, [fp, #-16] ; src
   106c8:	e5933010 	ldr	r3, [r3, #16]  ; r3 = src->max_size
   106cc:	e0822003 	add	r2, r2, r3     ; r2 = src->rear + src->max_size
   106d0:	e51b3010 	ldr	r3, [fp, #-16] ; src
   106d4:	e5832008 	str	r2, [r3, #8]   ; src->rear = r2
  }

  src->max_size = 2 * src->max_size;
   106d8:	e51b3010 	ldr	r3, [fp, #-16] ; src
   106dc:	e5933010 	ldr	r3, [r3, #16]  ; src->max_size
   106e0:	e1a02083 	lsl	r2, r3, #1     ; r2 = src->max_size<<1
   106e4:	e51b3010 	ldr	r3, [fp, #-16] ; src
   106e8:	e5832010 	str	r2, [r3, #16]  ; src->max_size = r2
}
   106ec:	e24bd004 	sub	sp, fp, #4
   106f0:	e8bd8800 	pop	{fp, pc}
   106f4:	00010f28 	.word	0x00010f28

000106f8 <init>:

void init(struct queue * src, int ms)
{
   106f8:	e92d4800 	push	{fp, lr}
   106fc:	e28db004 	add	fp, sp, #4
   10700:	e24dd008 	sub	sp, sp, #8
   10704:	e50b0008 	str	r0, [fp, #-8] ; src
   10708:	e50b100c 	str	r1, [fp, #-12] ; ms
  if (ms <= 0)
   1070c:	e51b300c 	ldr	r3, [fp, #-12] ; ms
   10710:	e3530000 	cmp	r3, #0         ; r3 = 0
   10714:	ca000001 	bgt	10720 <init+0x28>
    exit(1);
   10718:	e3a00001 	mov	r0, #1
   1071c:	ebffff51 	bl	10468 <exit@plt>

  src->max_size = ms;
   10720:	e51b3008 	ldr	r3, [fp, #-8] ; src
   10724:	e51b200c 	ldr	r2, [fp, #-12] ; ms
   10728:	e5832010 	str	r2, [r3, #16]  ; src->max_size
  src->queue = malloc (ms * sizeof(int));
   1072c:	e51b300c 	ldr	r3, [fp, #-12] ; ms
   10730:	e1a03103 	lsl	r3, r3, #2     ; ms=ms<<2
   10734:	e1a00003 	mov	r0, r3         ; r0 = ms
   10738:	ebffff3b 	bl	1042c <malloc@plt>
   1073c:	e1a03000 	mov	r3, r0 ; malloc return value
   10740:	e1a02003 	mov	r2, r3 ; r2 = malloc return value
   10744:	e51b3008 	ldr	r3, [fp, #-8] ; src
   10748:	e5832000 	str	r2, [r3]      ; src->queue = malloc
  if (src->queue == NULL)
   1074c:	e51b3008 	ldr	r3, [fp, #-8] ; src
   10750:	e5933000 	ldr	r3, [r3]      ; src->queue
   10754:	e3530000 	cmp	r3, #0
   10758:	1a000001 	bne	10764 <init+0x6c>
    exit(1);
   1075c:	e3a00001 	mov	r0, #1
   10760:	ebffff40 	bl	10468 <exit@plt>

  src->front = src->rear = 0;
   10764:	e51b3008 	ldr	r3, [fp, #-8] ; src
   10768:	e3a02000 	mov	r2, #0        ; r2 = 0
   1076c:	e5832008 	str	r2, [r3, #8]  ; src->rear = 0
   10770:	e51b3008 	ldr	r3, [fp, #-8] ; src
   10774:	e5932008 	ldr	r2, [r3, #8]  ; r2 = src->rear
   10778:	e51b3008 	ldr	r3, [fp, #-8] ; src
   1077c:	e5832004 	str	r2, [r3, #4]  ; src->front = src->rear
}
   10780:	e24bd004 	sub	sp, fp, #4
   10784:	e8bd8800 	pop	{fp, pc}

00010788 <in>:

void in(struct queue * src, int value)
{
   10788:	e92d4800 	push	{fp, lr}
   1078c:	e28db004 	add	fp, sp, #4
   10790:	e24dd008 	sub	sp, sp, #8
   10794:	e50b0008 	str	r0, [fp, #-8] ; src
   10798:	e50b100c 	str	r1, [fp, #-12] ; value
  //if ((src->rear + 1) % src->max_size == src->front)
  //src->rear = (src->rear + 1) % src->max_size;

  if (src->rear == src->max_size) {
   1079c:	e51b3008 	ldr	r3, [fp, #-8] ; src
   107a0:	e5932008 	ldr	r2, [r3, #8]  ; src->rear
   107a4:	e51b3008 	ldr	r3, [fp, #-8] ; src
   107a8:	e5933010 	ldr	r3, [r3, #16] ; src->max_size
   107ac:	e1520003 	cmp	r2, r3
   107b0:	1a000002 	bne	107c0 <in+0x38>
    printf("queue was bottom.\n");
   107b4:	e59f0040 	ldr	r0, [pc, #64]	; 107fc <in+0x74>
   107b8:	ebffff18 	bl	10420 <puts@plt>
    return ;
   107bc:	ea00000c 	b	107f4 <in+0x6c>
  }
  else {
    src->queue[src->rear] = value;
   107c0:	e51b3008 	ldr	r3, [fp, #-8] ; src
   107c4:	e5932000 	ldr	r2, [r3]      ; src->queue
   107c8:	e51b3008 	ldr	r3, [fp, #-8] ; src
   107cc:	e5933008 	ldr	r3, [r3, #8]  ; r3 = src->rear
   107d0:	e1a03103 	lsl	r3, r3, #2    ; src->rear=srec->rear<<2
   107d4:	e0823003 	add	r3, r2, r3    ; src->rear=src->queue+r3
   107d8:	e51b200c 	ldr	r2, [fp, #-12] ; value
   107dc:	e5832000 	str	r2, [r3]       ; src->queue[src->rear]=value
    src->rear++;
   107e0:	e51b3008 	ldr	r3, [fp, #-8] ; src
   107e4:	e5933008 	ldr	r3, [r3, #8]  ; src->rear
   107e8:	e2832001 	add	r2, r3, #1    ; r2 = src->rear+1
   107ec:	e51b3008 	ldr	r3, [fp, #-8] ; src
   107f0:	e5832008 	str	r2, [r3, #8]  ; src->rear = src->rear+1
  }
}
   107f4:	e24bd004 	sub	sp, fp, #4
   107f8:	e8bd8800 	pop	{fp, pc}
   107fc:	00010f38 	.word	0x00010f38

00010800 <out>:

int out(struct queue * src)
{
   10800:	e92d4800 	push	{fp, lr}
   10804:	e28db004 	add	fp, sp, #4
   10808:	e24dd010 	sub	sp, sp, #16
   1080c:	e50b0010 	str	r0, [fp, #-16] ; src
  int temp;

  if (src->front == src->rear) {
   10810:	e51b3010 	ldr	r3, [fp, #-16] ; src
   10814:	e5932004 	ldr	r2, [r3, #4]   ; src->front
   10818:	e51b3010 	ldr	r3, [fp, #-16] ; src
   1081c:	e5933008 	ldr	r3, [r3, #8]   ; src->rear
   10820:	e1520003 	cmp	r2, r3
   10824:	1a000003 	bne	10838 <out+0x38>
    printf("queueu was empty.\n");
   10828:	e59f0080 	ldr	r0, [pc, #128]	; 108b0 <out+0xb0>
   1082c:	ebfffefb 	bl	10420 <puts@plt>
    exit(1);
   10830:	e3a00001 	mov	r0, #1
   10834:	ebffff0b 	bl	10468 <exit@plt>
  }

  // src->front = (src->front + 1) % src->max_size;
  temp = src->queue[src->front];
   10838:	e51b3010 	ldr	r3, [fp, #-16] ; src
   1083c:	e5932000 	ldr	r2, [r3]       ; src->queue
   10840:	e51b3010 	ldr	r3, [fp, #-16] ; src
   10844:	e5933004 	ldr	r3, [r3, #4]   ; src->front
   10848:	e1a03103 	lsl	r3, r3, #2     ; src->front=src->front<<2
   1084c:	e0823003 	add	r3, r2, r3     ; src->front=src->queue+src->front<<2
   10850:	e5933000 	ldr	r3, [r3]       ; src->queue
   10854:	e50b3008 	str	r3, [fp, #-8]  ; src=src->queue
  src->front++;
   10858:	e51b3010 	ldr	r3, [fp, #-16] ; src
   1085c:	e5933004 	ldr	r3, [r3, #4]   ; src->front
   10860:	e2832001 	add	r2, r3, #1     ; src->front+1
   10864:	e51b3010 	ldr	r3, [fp, #-16] ; src
   10868:	e5832004 	str	r2, [r3, #4]   ; src->front=src->front+1
  if (src->front == src->rear)
   1086c:	e51b3010 	ldr	r3, [fp, #-16] ; src
   10870:	e5932004 	ldr	r2, [r3, #4]   ; src->front
   10874:	e51b3010 	ldr	r3, [fp, #-16] ; src
   10878:	e5933008 	ldr	r3, [r3, #8]   ; src->rear
   1087c:	e1520003 	cmp	r2, r3
   10880:	1a000006 	bne	108a0 <out+0xa0>
    src->front = src->rear = 0;
   10884:	e51b3010 	ldr	r3, [fp, #-16] ; src
   10888:	e3a02000 	mov	r2, #0
   1088c:	e5832008 	str	r2, [r3, #8] ; src->rear = 0
   10890:	e51b3010 	ldr	r3, [fp, #-16] ; src
   10894:	e5932008 	ldr	r2, [r3, #8]   ; src->rear
   10898:	e51b3010 	ldr	r3, [fp, #-16] ; src
   1089c:	e5832004 	str	r2, [r3, #4]   ; src->front=src->rear

  return temp;
   108a0:	e51b3008 	ldr	r3, [fp, #-8]
  // return src->queue[src->front++];
}
   108a4:	e1a00003 	mov	r0, r3
   108a8:	e24bd004 	sub	sp, fp, #4
   108ac:	e8bd8800 	pop	{fp, pc}
   108b0:	00010f4c 	.word	0x00010f4c

000108b4 <peek>:

int peek(struct queue * src)
{
   108b4:	e92d4810 	push	{r4, fp, lr}
   108b8:	e28db008 	add	fp, sp, #8
   108bc:	e24dd00c 	sub	sp, sp, #12
   108c0:	e50b0010 	str	r0, [fp, #-16] ; src
  if (src->front == src->rear) {
   108c4:	e51b3010 	ldr	r3, [fp, #-16] ; src
   108c8:	e5932004 	ldr	r2, [r3, #4]   ; src->front
   108cc:	e51b3010 	ldr	r3, [fp, #-16] ; src
   108d0:	e5933008 	ldr	r3, [r3, #8]   ; src->rear
   108d4:	e1520003 	cmp	r2, r3
   108d8:	1a000003 	bne	108ec <peek+0x38>
    printf("queue was empty.\n");
   108dc:	e59f004c 	ldr	r0, [pc, #76]	; 10930 <peek+0x7c>
   108e0:	ebfffece 	bl	10420 <puts@plt>
    exit(1);
   108e4:	e3a00001 	mov	r0, #1
   108e8:	ebfffede 	bl	10468 <exit@plt>
  }

  return src->queue[(src->front + 1) % src->max_size];
   108ec:	e51b3010 	ldr	r3, [fp, #-16]   ; src
   108f0:	e5934000 	ldr	r4, [r3]         ; r4 = src->queue
   108f4:	e51b3010 	ldr	r3, [fp, #-16]   ; src
   108f8:	e5933004 	ldr	r3, [r3, #4]     ; src->front
   108fc:	e2832001 	add	r2, r3, #1       ; r2 = src->front+1
   10900:	e51b3010 	ldr	r3, [fp, #-16]   ; src
   10904:	e5933010 	ldr	r3, [r3, #16]    ; src->max_size
   10908:	e1a01003 	mov	r1, r3           ; r1 = src->max_size
   1090c:	e1a00002 	mov	r0, r2           ; r0 = src->front+1
   10910:	eb000174 	bl	10ee8 <__aeabi_idivmod>
   10914:	e1a03001 	mov	r3, r1           ; src->max_size
   10918:	e1a03103 	lsl	r3, r3, #2       ; r3 = src->max_size<<2
   1091c:	e0843003 	add	r3, r4, r3       ; r3 = r4+r3
   10920:	e5933000 	ldr	r3, [r3]         ; src = r3+r4
}
   10924:	e1a00003 	mov	r0, r3
   10928:	e24bd008 	sub	sp, fp, #8
   1092c:	e8bd8810 	pop	{r4, fp, pc}
   10930:	00010f60 	.word	0x00010f60

00010934 <empty>:

int empty(struct queue * src) 
{
   10934:	e52db004 	push	{fp}		; (str fp, [sp, #-4]!)
   10938:	e28db000 	add	fp, sp, #0
   1093c:	e24dd00c 	sub	sp, sp, #12
   10940:	e50b0008 	str	r0, [fp, #-8] ; src
  if (src->front == src->rear)
   10944:	e51b3008 	ldr	r3, [fp, #-8] ; src
   10948:	e5932004 	ldr	r2, [r3, #4]  ; src->front
   1094c:	e51b3008 	ldr	r3, [fp, #-8] ; src
   10950:	e5933008 	ldr	r3, [r3, #8]  ; src->rear
   10954:	e1520003 	cmp	r2, r3
   10958:	1a000001 	bne	10964 <empty+0x30>
    return 1;
   1095c:	e3a03001 	mov	r3, #1
   10960:	ea000000 	b	10968 <empty+0x34>
  else
    return 0;
   10964:	e3a03000 	mov	r3, #0
}
   10968:	e1a00003 	mov	r0, r3
   1096c:	e24bd000 	sub	sp, fp, #0
   10970:	e49db004 	pop	{fp}		; (ldr fp, [sp], #4)
   10974:	e12fff1e 	bx	lr

00010978 <clear>:

void clear(struct queue * src)
{
   10978:	e92d4800 	push	{fp, lr}
   1097c:	e28db004 	add	fp, sp, #4
   10980:	e24dd008 	sub	sp, sp, #8
   10984:	e50b0008 	str	r0, [fp, #-8] ; src
  if (src->queue != NULL) {
   10988:	e51b3008 	ldr	r3, [fp, #-8] ; src
   1098c:	e5933000 	ldr	r3, [r3]      ; src->queue
   10990:	e3530000 	cmp	r3, #0
   10994:	0a000010 	beq	109dc <clear+0x64>
    free(src->queue);
   10998:	e51b3008 	ldr	r3, [fp, #-8] ; src
   1099c:	e5933000 	ldr	r3, [r3]      ; src->queue
   109a0:	e1a00003 	mov	r0, r3        ;
   109a4:	ebfffeb8 	bl	1048c <free@plt>
    src->queue = NULL;
   109a8:	e51b3008 	ldr	r3, [fp, #-8] ; src
   109ac:	e3a02000 	mov	r2, #0        ; 0
   109b0:	e5832000 	str	r2, [r3]      ; src->queue = 0
    src->front = src->rear = 0;
   109b4:	e51b3008 	ldr	r3, [fp, #-8] ; src
   109b8:	e3a02000 	mov	r2, #0
   109bc:	e5832008 	str	r2, [r3, #8]  ; src->rear = 0
   109c0:	e51b3008 	ldr	r3, [fp, #-8] ; src
   109c4:	e5932008 	ldr	r2, [r3, #8]  ; src->rear
   109c8:	e51b3008 	ldr	r3, [fp, #-8] ; src
   109cc:	e5832004 	str	r2, [r3, #4]  ; src->front=src->rear
    src->max_size = 0;
   109d0:	e51b3008 	ldr	r3, [fp, #-8] ; src
   109d4:	e3a02000 	mov	r2, #0
   109d8:	e5832010 	str	r2, [r3, #16] ; src->max_size = 0
  }
}
   109dc:	e24bd004 	sub	sp, fp, #4
   109e0:	e8bd8800 	pop	{fp, pc}

000109e4 <display>:

void display(struct queue * src)
{
   109e4:	e92d4800 	push	{fp, lr}
   109e8:	e28db004 	add	fp, sp, #4
   109ec:	e24dd010 	sub	sp, sp, #16
   109f0:	e50b0010 	str	r0, [fp, #-16] ; src
  int i;

  i = src->front;
   109f4:	e51b3010 	ldr	r3, [fp, #-16] ; src
   109f8:	e5933004 	ldr	r3, [r3, #4]   ; src->front
   109fc:	e50b3008 	str	r3, [fp, #-8]  ; i
  printf("queue element is :\n");
   10a00:	e59f0068 	ldr	r0, [pc, #104]	; 10a70 <display+0x8c>
   10a04:	ebfffe85 	bl	10420 <puts@plt>
  /*  while ((i % (src->max_size)) != src->rear ) {
    printf(" i=%d: %d ", i, src->queue[i]);
    i++;
    }*/

  for (i = src->front; i <= src->rear-1; i++) 
   10a08:	e51b3010 	ldr	r3, [fp, #-16] ; src
   10a0c:	e5933004 	ldr	r3, [r3, #4]   ; src->front
   10a10:	e50b3008 	str	r3, [fp, #-8]  ; i
   10a14:	ea00000b 	b	10a48 <display+0x64>
    printf("%d ", src->queue[i]);
   10a18:	e51b3010 	ldr	r3, [fp, #-16] ; src
   10a1c:	e5932000 	ldr	r2, [r3]       ; r2 = src->queue
   10a20:	e51b3008 	ldr	r3, [fp, #-8]  ; i
   10a24:	e1a03103 	lsl	r3, r3, #2     ; r3 = i << 2
   10a28:	e0823003 	add	r3, r2, r3     ; i = src->queue+i<<2
   10a2c:	e5933000 	ldr	r3, [r3]       ; src->queue = src->queue+i<<2
   10a30:	e1a01003 	mov	r1, r3         ; src->queue
   10a34:	e59f0038 	ldr	r0, [pc, #56]	; 10a74 <display+0x90>
   10a38:	ebfffe75 	bl	10414 <printf@plt>
  /*  while ((i % (src->max_size)) != src->rear ) {
    printf(" i=%d: %d ", i, src->queue[i]);
    i++;
    }*/

  for (i = src->front; i <= src->rear-1; i++) 
   10a3c:	e51b3008 	ldr	r3, [fp, #-8] ; i
   10a40:	e2833001 	add	r3, r3, #1    ; i+1
   10a44:	e50b3008 	str	r3, [fp, #-8] ; i = i+1
   10a48:	e51b3010 	ldr	r3, [fp, #-16] ; src
   10a4c:	e5933008 	ldr	r3, [r3, #8]   ; src->rear
   10a50:	e2432001 	sub	r2, r3, #1     ; r2 = src->rear - 1
   10a54:	e51b3008 	ldr	r3, [fp, #-8]  ; r3 = i
   10a58:	e1520003 	cmp	r2, r3
   10a5c:	aaffffed 	bge	10a18 <display+0x34>
    printf("%d ", src->queue[i]);

  printf("\n\n");
   10a60:	e59f0010 	ldr	r0, [pc, #16]	; 10a78 <display+0x94>
   10a64:	ebfffe6d 	bl	10420 <puts@plt>
}
   10a68:	e24bd004 	sub	sp, fp, #4
   10a6c:	e8bd8800 	pop	{fp, pc}
   10a70:	00010f74 	.word	0x00010f74
   10a74:	00010f88 	.word	0x00010f88
   10a78:	00010f8c 	.word	0x00010f8c

00010a7c <main>:

int main()
{
   10a7c:	e92d4800 	push	{fp, lr}
   10a80:	e28db004 	add	fp, sp, #4 ; fp = sp + 4
   10a84:	e24dd018 	sub	sp, sp, #24 ; sp = sp - 24
  struct queue queue;
  
  init(& queue, 10);
   10a88:	e24b3018 	sub	r3, fp, #24 ; r3 = fp - 24
   10a8c:	e3a0100a 	mov	r1, #10
   10a90:	e1a00003 	mov	r0, r3
   10a94:	ebffff17 	bl	106f8 <init>
  in(& queue, 1);
   10a98:	e24b3018 	sub	r3, fp, #24
   10a9c:	e3a01001 	mov	r1, #1
   10aa0:	e1a00003 	mov	r0, r3
   10aa4:	ebffff37 	bl	10788 <in>
  in(& queue, 2);
   10aa8:	e24b3018 	sub	r3, fp, #24
   10aac:	e3a01002 	mov	r1, #2
   10ab0:	e1a00003 	mov	r0, r3
   10ab4:	ebffff33 	bl	10788 <in>
  in(& queue, 3);
   10ab8:	e24b3018 	sub	r3, fp, #24
   10abc:	e3a01003 	mov	r1, #3
   10ac0:	e1a00003 	mov	r0, r3
   10ac4:	ebffff2f 	bl	10788 <in>
  in(& queue, 4);
   10ac8:	e24b3018 	sub	r3, fp, #24
   10acc:	e3a01004 	mov	r1, #4
   10ad0:	e1a00003 	mov	r0, r3
   10ad4:	ebffff2b 	bl	10788 <in>
  in(& queue, 5);
   10ad8:	e24b3018 	sub	r3, fp, #24
   10adc:	e3a01005 	mov	r1, #5
   10ae0:	e1a00003 	mov	r0, r3
   10ae4:	ebffff27 	bl	10788 <in>
  in(& queue, 6);
   10ae8:	e24b3018 	sub	r3, fp, #24
   10aec:	e3a01006 	mov	r1, #6
   10af0:	e1a00003 	mov	r0, r3
   10af4:	ebffff23 	bl	10788 <in>
  in(& queue, 7);
   10af8:	e24b3018 	sub	r3, fp, #24
   10afc:	e3a01007 	mov	r1, #7
   10b00:	e1a00003 	mov	r0, r3
   10b04:	ebffff1f 	bl	10788 <in>
  in(& queue, 8);
   10b08:	e24b3018 	sub	r3, fp, #24
   10b0c:	e3a01008 	mov	r1, #8
   10b10:	e1a00003 	mov	r0, r3
   10b14:	ebffff1b 	bl	10788 <in>
  in(& queue, 9);
   10b18:	e24b3018 	sub	r3, fp, #24
   10b1c:	e3a01009 	mov	r1, #9
   10b20:	e1a00003 	mov	r0, r3
   10b24:	ebffff17 	bl	10788 <in>
  in(& queue, 10);
   10b28:	e24b3018 	sub	r3, fp, #24
   10b2c:	e3a0100a 	mov	r1, #10
   10b30:	e1a00003 	mov	r0, r3
   10b34:	ebffff13 	bl	10788 <in>
  in(& queue, 11);	// queue was bottom.
   10b38:	e24b3018 	sub	r3, fp, #24
   10b3c:	e3a0100b 	mov	r1, #11
   10b40:	e1a00003 	mov	r0, r3
   10b44:	ebffff0f 	bl	10788 <in>
  display(& queue);	// 1 2 3 4 5 6 7 8 9 10
   10b48:	e24b3018 	sub	r3, fp, #24
   10b4c:	e1a00003 	mov	r0, r3
   10b50:	ebffffa3 	bl	109e4 <display>
  
  out(& queue);		// del 1
   10b54:	e24b3018 	sub	r3, fp, #24
   10b58:	e1a00003 	mov	r0, r3
   10b5c:	ebffff27 	bl	10800 <out>
  out(& queue);		// del 2
   10b60:	e24b3018 	sub	r3, fp, #24
   10b64:	e1a00003 	mov	r0, r3
   10b68:	ebffff24 	bl	10800 <out>
  out(& queue);		// del 3
   10b6c:	e24b3018 	sub	r3, fp, #24
   10b70:	e1a00003 	mov	r0, r3
   10b74:	ebffff21 	bl	10800 <out>
  display(& queue);	// 4 5 6 7 8 9 10
   10b78:	e24b3018 	sub	r3, fp, #24
   10b7c:	e1a00003 	mov	r0, r3
   10b80:	ebffff97 	bl	109e4 <display>

  in(& queue, 77);	// queue was bottom. 因为不是循环队列，需全部出列后才能再次入列，以下增加所测。
   10b84:	e24b3018 	sub	r3, fp, #24
   10b88:	e3a0104d 	mov	r1, #77	; 0x4d
   10b8c:	e1a00003 	mov	r0, r3
   10b90:	ebfffefc 	bl	10788 <in>
  //  in(& queue, 8);
  //in(& queue, 9);
  //in(& queue, 10);
  display(& queue);	// 4 5 6 7 8 9 10
   10b94:	e24b3018 	sub	r3, fp, #24
   10b98:	e1a00003 	mov	r0, r3
   10b9c:	ebffff90 	bl	109e4 <display>
  

  /*
   * 2017/7/27 再次调试所加
   */
  out(& queue);		// del 4
   10ba0:	e24b3018 	sub	r3, fp, #24
   10ba4:	e1a00003 	mov	r0, r3
   10ba8:	ebffff14 	bl	10800 <out>
  out(& queue);		// del 5
   10bac:	e24b3018 	sub	r3, fp, #24
   10bb0:	e1a00003 	mov	r0, r3
   10bb4:	ebffff11 	bl	10800 <out>
  out(& queue);		// del 6
   10bb8:	e24b3018 	sub	r3, fp, #24
   10bbc:	e1a00003 	mov	r0, r3
   10bc0:	ebffff0e 	bl	10800 <out>
  out(& queue);		// del 7
   10bc4:	e24b3018 	sub	r3, fp, #24
   10bc8:	e1a00003 	mov	r0, r3
   10bcc:	ebffff0b 	bl	10800 <out>
  out(& queue);		// del 8
   10bd0:	e24b3018 	sub	r3, fp, #24
   10bd4:	e1a00003 	mov	r0, r3
   10bd8:	ebffff08 	bl	10800 <out>
  out(& queue);		// del 9
   10bdc:	e24b3018 	sub	r3, fp, #24
   10be0:	e1a00003 	mov	r0, r3
   10be4:	ebffff05 	bl	10800 <out>
  out(& queue);		// del 10
   10be8:	e24b3018 	sub	r3, fp, #24
   10bec:	e1a00003 	mov	r0, r3
   10bf0:	ebffff02 	bl	10800 <out>
  display(& queue);	// 空
   10bf4:	e24b3018 	sub	r3, fp, #24
   10bf8:	e1a00003 	mov	r0, r3
   10bfc:	ebffff78 	bl	109e4 <display>

  in(& queue, 11);
   10c00:	e24b3018 	sub	r3, fp, #24
   10c04:	e3a0100b 	mov	r1, #11
   10c08:	e1a00003 	mov	r0, r3
   10c0c:	ebfffedd 	bl	10788 <in>
  in(& queue, 22);
   10c10:	e24b3018 	sub	r3, fp, #24
   10c14:	e3a01016 	mov	r1, #22
   10c18:	e1a00003 	mov	r0, r3
   10c1c:	ebfffed9 	bl	10788 <in>
  in(& queue, 23);
   10c20:	e24b3018 	sub	r3, fp, #24
   10c24:	e3a01017 	mov	r1, #23
   10c28:	e1a00003 	mov	r0, r3
   10c2c:	ebfffed5 	bl	10788 <in>
  in(& queue, 24);
   10c30:	e24b3018 	sub	r3, fp, #24
   10c34:	e3a01018 	mov	r1, #24
   10c38:	e1a00003 	mov	r0, r3
   10c3c:	ebfffed1 	bl	10788 <in>
  in(& queue, 25);
   10c40:	e24b3018 	sub	r3, fp, #24
   10c44:	e3a01019 	mov	r1, #25
   10c48:	e1a00003 	mov	r0, r3
   10c4c:	ebfffecd 	bl	10788 <in>
  in(& queue, 26);
   10c50:	e24b3018 	sub	r3, fp, #24
   10c54:	e3a0101a 	mov	r1, #26
   10c58:	e1a00003 	mov	r0, r3
   10c5c:	ebfffec9 	bl	10788 <in>
  in(& queue, 27);
   10c60:	e24b3018 	sub	r3, fp, #24
   10c64:	e3a0101b 	mov	r1, #27
   10c68:	e1a00003 	mov	r0, r3
   10c6c:	ebfffec5 	bl	10788 <in>
  in(& queue, 28);
   10c70:	e24b3018 	sub	r3, fp, #24
   10c74:	e3a0101c 	mov	r1, #28
   10c78:	e1a00003 	mov	r0, r3
   10c7c:	ebfffec1 	bl	10788 <in>
  in(& queue, 29);
   10c80:	e24b3018 	sub	r3, fp, #24
   10c84:	e3a0101d 	mov	r1, #29
   10c88:	e1a00003 	mov	r0, r3
   10c8c:	ebfffebd 	bl	10788 <in>
  in(& queue, 30);
   10c90:	e24b3018 	sub	r3, fp, #24
   10c94:	e3a0101e 	mov	r1, #30
   10c98:	e1a00003 	mov	r0, r3
   10c9c:	ebfffeb9 	bl	10788 <in>
  in(& queue, 31);	// queue was bottom.
   10ca0:	e24b3018 	sub	r3, fp, #24
   10ca4:	e3a0101f 	mov	r1, #31
   10ca8:	e1a00003 	mov	r0, r3
   10cac:	ebfffeb5 	bl	10788 <in>
  display(& queue); // 11 22 23 24 25 26 27 28 29 30
   10cb0:	e24b3018 	sub	r3, fp, #24
   10cb4:	e1a00003 	mov	r0, r3
   10cb8:	ebffff49 	bl	109e4 <display>
}
   10cbc:	e1a00003 	mov	r0, r3
   10cc0:	e24bd004 	sub	sp, fp, #4
   10cc4:	e8bd8800 	pop	{fp, pc}

00010cc8 <__aeabi_idiv>:
   10cc8:	e3510000 	cmp	r1, #0
   10ccc:	0a000081 	beq	10ed8 <.divsi3_skip_div0_test+0x208>

00010cd0 <.divsi3_skip_div0_test>:
   10cd0:	e020c001 	eor	ip, r0, r1
   10cd4:	42611000 	rsbmi	r1, r1, #0
   10cd8:	e2512001 	subs	r2, r1, #1
   10cdc:	0a000070 	beq	10ea4 <.divsi3_skip_div0_test+0x1d4>
   10ce0:	e1b03000 	movs	r3, r0
   10ce4:	42603000 	rsbmi	r3, r0, #0
   10ce8:	e1530001 	cmp	r3, r1
   10cec:	9a00006f 	bls	10eb0 <.divsi3_skip_div0_test+0x1e0>
   10cf0:	e1110002 	tst	r1, r2
   10cf4:	0a000071 	beq	10ec0 <.divsi3_skip_div0_test+0x1f0>
   10cf8:	e16f2f13 	clz	r2, r3
   10cfc:	e16f0f11 	clz	r0, r1
   10d00:	e0402002 	sub	r2, r0, r2
   10d04:	e272201f 	rsbs	r2, r2, #31
   10d08:	10822082 	addne	r2, r2, r2, lsl #1
   10d0c:	e3a00000 	mov	r0, #0
   10d10:	108ff102 	addne	pc, pc, r2, lsl #2
   10d14:	e1a00000 	nop			; (mov r0, r0)
   10d18:	e1530f81 	cmp	r3, r1, lsl #31
   10d1c:	e0a00000 	adc	r0, r0, r0
   10d20:	20433f81 	subcs	r3, r3, r1, lsl #31
   10d24:	e1530f01 	cmp	r3, r1, lsl #30
   10d28:	e0a00000 	adc	r0, r0, r0
   10d2c:	20433f01 	subcs	r3, r3, r1, lsl #30
   10d30:	e1530e81 	cmp	r3, r1, lsl #29
   10d34:	e0a00000 	adc	r0, r0, r0
   10d38:	20433e81 	subcs	r3, r3, r1, lsl #29
   10d3c:	e1530e01 	cmp	r3, r1, lsl #28
   10d40:	e0a00000 	adc	r0, r0, r0
   10d44:	20433e01 	subcs	r3, r3, r1, lsl #28
   10d48:	e1530d81 	cmp	r3, r1, lsl #27
   10d4c:	e0a00000 	adc	r0, r0, r0
   10d50:	20433d81 	subcs	r3, r3, r1, lsl #27
   10d54:	e1530d01 	cmp	r3, r1, lsl #26
   10d58:	e0a00000 	adc	r0, r0, r0
   10d5c:	20433d01 	subcs	r3, r3, r1, lsl #26
   10d60:	e1530c81 	cmp	r3, r1, lsl #25
   10d64:	e0a00000 	adc	r0, r0, r0
   10d68:	20433c81 	subcs	r3, r3, r1, lsl #25
   10d6c:	e1530c01 	cmp	r3, r1, lsl #24
   10d70:	e0a00000 	adc	r0, r0, r0
   10d74:	20433c01 	subcs	r3, r3, r1, lsl #24
   10d78:	e1530b81 	cmp	r3, r1, lsl #23
   10d7c:	e0a00000 	adc	r0, r0, r0
   10d80:	20433b81 	subcs	r3, r3, r1, lsl #23
   10d84:	e1530b01 	cmp	r3, r1, lsl #22
   10d88:	e0a00000 	adc	r0, r0, r0
   10d8c:	20433b01 	subcs	r3, r3, r1, lsl #22
   10d90:	e1530a81 	cmp	r3, r1, lsl #21
   10d94:	e0a00000 	adc	r0, r0, r0
   10d98:	20433a81 	subcs	r3, r3, r1, lsl #21
   10d9c:	e1530a01 	cmp	r3, r1, lsl #20
   10da0:	e0a00000 	adc	r0, r0, r0
   10da4:	20433a01 	subcs	r3, r3, r1, lsl #20
   10da8:	e1530981 	cmp	r3, r1, lsl #19
   10dac:	e0a00000 	adc	r0, r0, r0
   10db0:	20433981 	subcs	r3, r3, r1, lsl #19
   10db4:	e1530901 	cmp	r3, r1, lsl #18
   10db8:	e0a00000 	adc	r0, r0, r0
   10dbc:	20433901 	subcs	r3, r3, r1, lsl #18
   10dc0:	e1530881 	cmp	r3, r1, lsl #17
   10dc4:	e0a00000 	adc	r0, r0, r0
   10dc8:	20433881 	subcs	r3, r3, r1, lsl #17
   10dcc:	e1530801 	cmp	r3, r1, lsl #16
   10dd0:	e0a00000 	adc	r0, r0, r0
   10dd4:	20433801 	subcs	r3, r3, r1, lsl #16
   10dd8:	e1530781 	cmp	r3, r1, lsl #15
   10ddc:	e0a00000 	adc	r0, r0, r0
   10de0:	20433781 	subcs	r3, r3, r1, lsl #15
   10de4:	e1530701 	cmp	r3, r1, lsl #14
   10de8:	e0a00000 	adc	r0, r0, r0
   10dec:	20433701 	subcs	r3, r3, r1, lsl #14
   10df0:	e1530681 	cmp	r3, r1, lsl #13
   10df4:	e0a00000 	adc	r0, r0, r0
   10df8:	20433681 	subcs	r3, r3, r1, lsl #13
   10dfc:	e1530601 	cmp	r3, r1, lsl #12
   10e00:	e0a00000 	adc	r0, r0, r0
   10e04:	20433601 	subcs	r3, r3, r1, lsl #12
   10e08:	e1530581 	cmp	r3, r1, lsl #11
   10e0c:	e0a00000 	adc	r0, r0, r0
   10e10:	20433581 	subcs	r3, r3, r1, lsl #11
   10e14:	e1530501 	cmp	r3, r1, lsl #10
   10e18:	e0a00000 	adc	r0, r0, r0
   10e1c:	20433501 	subcs	r3, r3, r1, lsl #10
   10e20:	e1530481 	cmp	r3, r1, lsl #9
   10e24:	e0a00000 	adc	r0, r0, r0
   10e28:	20433481 	subcs	r3, r3, r1, lsl #9
   10e2c:	e1530401 	cmp	r3, r1, lsl #8
   10e30:	e0a00000 	adc	r0, r0, r0
   10e34:	20433401 	subcs	r3, r3, r1, lsl #8
   10e38:	e1530381 	cmp	r3, r1, lsl #7
   10e3c:	e0a00000 	adc	r0, r0, r0
   10e40:	20433381 	subcs	r3, r3, r1, lsl #7
   10e44:	e1530301 	cmp	r3, r1, lsl #6
   10e48:	e0a00000 	adc	r0, r0, r0
   10e4c:	20433301 	subcs	r3, r3, r1, lsl #6
   10e50:	e1530281 	cmp	r3, r1, lsl #5
   10e54:	e0a00000 	adc	r0, r0, r0
   10e58:	20433281 	subcs	r3, r3, r1, lsl #5
   10e5c:	e1530201 	cmp	r3, r1, lsl #4
   10e60:	e0a00000 	adc	r0, r0, r0
   10e64:	20433201 	subcs	r3, r3, r1, lsl #4
   10e68:	e1530181 	cmp	r3, r1, lsl #3
   10e6c:	e0a00000 	adc	r0, r0, r0
   10e70:	20433181 	subcs	r3, r3, r1, lsl #3
   10e74:	e1530101 	cmp	r3, r1, lsl #2
   10e78:	e0a00000 	adc	r0, r0, r0
   10e7c:	20433101 	subcs	r3, r3, r1, lsl #2
   10e80:	e1530081 	cmp	r3, r1, lsl #1
   10e84:	e0a00000 	adc	r0, r0, r0
   10e88:	20433081 	subcs	r3, r3, r1, lsl #1
   10e8c:	e1530001 	cmp	r3, r1
   10e90:	e0a00000 	adc	r0, r0, r0
   10e94:	20433001 	subcs	r3, r3, r1
   10e98:	e35c0000 	cmp	ip, #0
   10e9c:	42600000 	rsbmi	r0, r0, #0
   10ea0:	e12fff1e 	bx	lr
   10ea4:	e13c0000 	teq	ip, r0
   10ea8:	42600000 	rsbmi	r0, r0, #0
   10eac:	e12fff1e 	bx	lr
   10eb0:	33a00000 	movcc	r0, #0
   10eb4:	01a00fcc 	asreq	r0, ip, #31
   10eb8:	03800001 	orreq	r0, r0, #1
   10ebc:	e12fff1e 	bx	lr
   10ec0:	e16f2f11 	clz	r2, r1
   10ec4:	e262201f 	rsb	r2, r2, #31
   10ec8:	e35c0000 	cmp	ip, #0
   10ecc:	e1a00233 	lsr	r0, r3, r2
   10ed0:	42600000 	rsbmi	r0, r0, #0
   10ed4:	e12fff1e 	bx	lr
   10ed8:	e3500000 	cmp	r0, #0
   10edc:	c3e00102 	mvngt	r0, #-2147483648	; 0x80000000
   10ee0:	b3a00102 	movlt	r0, #-2147483648	; 0x80000000
   10ee4:	ea000007 	b	10f08 <__aeabi_idiv0>

00010ee8 <__aeabi_idivmod>:
   10ee8:	e3510000 	cmp	r1, #0
   10eec:	0afffff9 	beq	10ed8 <.divsi3_skip_div0_test+0x208>
   10ef0:	e92d4003 	push	{r0, r1, lr}
   10ef4:	ebffff75 	bl	10cd0 <.divsi3_skip_div0_test>
   10ef8:	e8bd4006 	pop	{r1, r2, lr}
   10efc:	e0030092 	mul	r3, r2, r0
   10f00:	e0411003 	sub	r1, r1, r3
   10f04:	e12fff1e 	bx	lr

00010f08 <__aeabi_idiv0>:
   10f08:	e92d4002 	push	{r1, lr}
   10f0c:	e3a00008 	mov	r0, #8
   10f10:	ebfffd5a 	bl	10480 <raise@plt>
   10f14:	e8bd8002 	pop	{r1, pc}

Disassembly of section .fini:

00010f18 <_fini>:
   10f18:	e1a0c00d 	mov	ip, sp
   10f1c:	e92ddff0 	push	{r4, r5, r6, r7, r8, r9, sl, fp, ip, lr, pc}
   10f20:	e24cb004 	sub	fp, ip, #4
   10f24:	e91baff0 	ldmdb	fp, {r4, r5, r6, r7, r8, r9, sl, fp, sp, pc}
